Premium Content

RUBY BASICS

Learn the fundamental concepts of Ruby programming

Beginner

Module 1: Introduction to Ruby

Ruby is a dynamic, open-source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write. In this module, you'll learn the basic structure of Ruby programs and how to write your first Ruby code.

Try It Yourself:

Ruby

# Welcome to Ruby Programming!
# This is a comment - it won't be executed

puts "Hello, World!"
puts "Welcome to SkillMynte Ruby Course!"

# Basic arithmetic operations
puts "2 + 3 = #{2 + 3}"
puts "10 - 5 = #{10 - 5}"
puts "4 * 6 = #{4 * 6}"
puts "15 / 3 = #{15 / 3}"

# String operations
name = "SkillMynte"
puts "Hello, #{name}!"
puts "The length of '#{name}' is #{name.length} characters"

# Boolean operations
puts "Is 5 greater than 3? #{5 > 3}"
puts "Is 10 equal to 10? #{10 == 10}"

# Try changing the values and see what happens!

Live Preview

Key Points:

puts is used to output text to the console
Comments start with # and are ignored by Ruby
Ruby supports basic arithmetic operations: +, -, *, /
Strings can be created with single or double quotes
String interpolation #{expression} works only with double quotes
Variables don't need type declarations (Ruby is dynamically typed)
Ruby uses == for equality comparison
Boolean values are true and false (all lowercase)

Premium Content

VARIABLES & DATA TYPES

Learn about Ruby's data types and variable handling

Beginner

Module 2: Variables and Data Types

Ruby is a dynamically typed language, meaning you don't have to declare variable types. It has several built-in data types including numbers, strings, booleans, arrays, and hashes. Understanding these fundamental types is crucial for effective Ruby programming.

Try It Yourself:

Ruby

# Variables and Data Types in Ruby

# Integer numbers
age = 25
year = 2024
puts "Age: #{age}, Year: #{year}"

# Floating point numbers
price = 19.99
temperature = 36.6
puts "Price: $#{price}, Temperature: #{temperature}Â°C"

# Strings
name = "Alice"
greeting = 'Hello'
puts "#{greeting}, #{name}!"

# Booleans
is_ruby_fun = true
is_learning = false
puts "Is Ruby fun? #{is_ruby_fun}"
puts "Are we learning? #{is_learning}"

# Arrays (ordered lists)
fruits = ["apple", "banana", "orange", "grape"]
puts "Fruits: #{fruits}"
puts "First fruit: #{fruits[0]}"
puts "Number of fruits: #{fruits.length}"

# Hashes (key-value pairs)
person = {
  "name" => "Bob",
  "age" => 30,
  "city" => "Lagos"
}
puts "Person: #{person}"
puts "Name: #{person['name']}"
puts "Age: #{person['age']}"

# Symbols (efficient identifiers)
status = :active
puts "Status: #{status}"

# Type checking
puts "Type of age: #{age.class}"
puts "Type of name: #{name.class}"
puts "Type of fruits: #{fruits.class}"
puts "Type of person: #{person.class}"

Live Preview

Key Points:

Variables start with lowercase letters and use snake_case: my_variable
Integer and Float are numeric types: 42 (integer) vs 3.14 (float)
Strings can use single or double quotes, but interpolation only works with double quotes
Arrays are ordered, zero-indexed collections: array[0] gets first element
Hashes store key-value pairs: hash["key"] = "value"
Symbols are immutable identifiers: :symbol_name (more memory efficient than strings)
Use .class to check an object's type
Ruby is dynamically typed - variables can hold different types during execution

Premium Content

CONTROL STRUCTURES

Learn to control program flow with conditionals and loops

Beginner

Module 3: Control Structures

Control structures allow your program to make decisions and repeat actions. Ruby provides conditional statements like if, unless, case and loops like while, until, and for to control the flow of your program.

Try It Yourself:

Ruby

# Control Structures in Ruby

# If-else statements
age = 20
if age >= 18
  puts "You are an adult"
else
  puts "You are a minor"
end

# Unless statement (opposite of if)
raining = false
unless raining
  puts "It's not raining. Let's go outside!"
else
  puts "It's raining. Stay inside."
end

# Case statement (like switch in other languages)
grade = "B"
case grade
when "A"
  puts "Excellent!"
when "B"
  puts "Good job!"
when "C"
  puts "You passed"
else
  puts "Try harder next time"
end

# While loop
counter = 1
while counter <= 5
  puts "Count: #{counter}"
  counter += 1
end

# Until loop (opposite of while)
number = 10
until number <= 0
  puts "Countdown: #{number}"
  number -= 2
end

# For loop with ranges
puts "Counting from 1 to 3:"
for i in 1..3
  puts i
end

# Each iterator (preferred Ruby way)
puts "Iterating with each:"
(1..3).each do |num|
  puts "Number: #{num}"
end

# Times iterator
puts "Using times:"
5.times do |i|
  puts "Iteration #{i + 1}"
end

# Conditional modifiers (one-liners)
puts "Hello" if true
puts "This won't print" if false

temperature = 25
puts "It's hot!" if temperature > 30

Live Preview

Key Points:

if executes code when condition is true
unless executes code when condition is false (opposite of if)
case statements are cleaner than multiple if-elsif statements
while loops continue while condition is true
until loops continue until condition becomes true
Ranges: 1..5 includes 5, 1...5 excludes 5
each is the preferred way to iterate in Ruby (more idiomatic than for)
times is useful for repeating a block a specific number of times
Conditional modifiers allow one-line conditionals: action if condition
Ruby uses end to close blocks, not curly braces like other languages

Premium Content

METHODS & FUNCTIONS

Learn to create reusable code with methods

Intermediate

Module 4: Methods and Functions

Methods in Ruby are reusable blocks of code that perform specific tasks. They help organize your code, make it more readable, and reduce repetition. Ruby methods can take parameters, return values, and even have default arguments.

Try It Yourself:

Ruby

# Methods and Functions in Ruby

# Basic method without parameters
def greet
  puts "Hello from SkillMynte!"
end

greet  # Calling the method

# Method with parameters
def greet_person(name)
  puts "Hello, #{name}!"
end

greet_person("Alice")
greet_person("Bob")

# Method with default parameters
def introduce(name, age = 25)
  puts "My name is #{name} and I'm #{age} years old."
end

introduce("Charlie")
introduce("Diana", 30)

# Method with return value
def add_numbers(a, b)
  return a + b
end

result = add_numbers(5, 3)
puts "5 + 3 = #{result}"

# Implicit return (last expression is returned automatically)
def multiply(a, b)
  a * b  # This is automatically returned
end

puts "4 * 6 = #{multiply(4, 6)}"

# Method with multiple return values
def calculate(a, b)
  sum = a + b
  difference = a - b
  product = a * b
  quotient = a / b.to_f  # Using to_f for floating point division
  
  return sum, difference, product, quotient
end

sum, diff, prod, quot = calculate(10, 3)
puts "Sum: #{sum}, Difference: #{diff}, Product: #{prod}, Quotient: #{quot}"

# Predicate methods (return boolean)
def is_adult?(age)
  age >= 18
end

puts "Is 20 an adult? #{is_adult?(20)}"
puts "Is 15 an adult? #{is_adult?(15)}"

# Bang methods (modify the object)
def make_uppercase!(text)
  text.upcase!
end

name = "skillmynte"
make_uppercase!(name)
puts "Uppercase name: #{name}"

# Variable number of arguments
def sum_all(*numbers)
  numbers.sum
end

puts "Sum: #{sum_all(1, 2, 3)}"
puts "Sum: #{sum_all(5, 10, 15, 20)}"

Live Preview

Key Points:

Methods are defined with def method_name and end with end
Method names should be lowercase with underscores: my_method_name
Parameters are specified in parentheses after the method name
Default parameters provide fallback values: def greet(name="Guest")
Ruby has implicit return - the last expression is automatically returned
Explicit return statements can be used for early returns
Methods can return multiple values as an array
Predicate methods end with ? and return boolean values
Bang methods end with ! and modify the object they're called on
Variable arguments use *args to accept any number of parameters
Method calls can omit parentheses: greet "Alice" vs greet("Alice")

Premium Content

ARRAYS & HASHES

Learn to work with collections in Ruby

Intermediate

Module 5: Arrays and Hashes

Arrays and hashes are fundamental data structures in Ruby. Arrays are ordered collections, while hashes are key-value pairs. Ruby provides powerful methods to manipulate these collections efficiently.

Try It Yourself:

Ruby

# Arrays and Hashes in Ruby

# Arrays - Ordered collections
fruits = ["apple", "banana", "orange"]
puts "Fruits: #{fruits}"

# Array methods
fruits << "grape"  # Add to end
fruits.push("mango")  # Another way to add
fruits.unshift("strawberry")  # Add to beginning

puts "After adding: #{fruits}"
puts "First fruit: #{fruits.first}"
puts "Last fruit: #{fruits.last}"
puts "Array length: #{fruits.length}"

# Removing elements
removed_fruit = fruits.pop  # Remove last element
puts "Removed: #{removed_fruit}"
puts "After pop: #{fruits}"

fruits.shift  # Remove first element
puts "After shift: #{fruits}"

# Array iteration
puts "Fruits list:"
fruits.each_with_index do |fruit, index|
  puts "#{index + 1}. #{fruit.capitalize}"
end

# Array transformation
numbers = [1, 2, 3, 4, 5]
squared = numbers.map { |n| n * n }
puts "Numbers: #{numbers}"
puts "Squared: #{squared}"

# Array filtering
even_numbers = numbers.select { |n| n.even? }
puts "Even numbers: #{even_numbers}"

# Hashes - Key-value pairs
student = {
  name: "Alice",
  age: 20,
  grade: "A",
  subjects: ["Math", "Science", "English"]
}

puts "Student: #{student}"

# Accessing hash values
puts "Name: #{student[:name]}"
puts "Age: #{student[:age]}"
puts "Subjects: #{student[:subjects].join(', ')}"

# Adding to hash
student[:school] = "SkillMynte Academy"
puts "After adding school: #{student}"

# Hash iteration
puts "Student details:"
student.each do |key, value|
  puts "#{key.capitalize}: #{value}"
end

# Nested collections
classroom = {
  teacher: "Mr. Smith",
  students: [
    {name: "Alice", grade: "A"},
    {name: "Bob", grade: "B"},
    {name: "Charlie", grade: "A"}
  ]
}

puts "Classroom teacher: #{classroom[:teacher]}"
puts "Students:"
classroom[:students].each do |student|
  puts "- #{student[:name]}: #{student[:grade]}"
end

# Useful array methods
mixed_array = [1, "hello", 3.14, true, [1, 2, 3]]
puts "Mixed array: #{mixed_array}"
puts "Sorted fruits: #{fruits.sort}"
puts "Reversed fruits: #{fruits.reverse}"
puts "Is fruits empty? #{fruits.empty?}"
puts "Does fruits include 'banana'? #{fruits.include?('banana')}"

Live Preview

Key Points:

Arrays are ordered, integer-indexed collections starting from 0
Hashes store key-value pairs (similar to dictionaries in other languages)
Symbol keys in hashes: {name: "Alice"} is shorthand for {:name => "Alice"}
Array methods: push/<< to add, pop to remove last, shift/unshift for first element
Use each for iteration, map for transformation, select for filtering
each_with_index provides both element and index during iteration
Hashes can be accessed with symbol keys: hash[:key]
Collections can be nested (arrays within hashes, hashes within arrays, etc.)
Useful array methods: sort, reverse, empty?, include?
join converts array to string with specified separator

Premium Content

OBJECT-ORIENTED RUBY

Learn Ruby's object-oriented programming features

Intermediate

Module 6: Object-Oriented Programming in Ruby

Ruby is a pure object-oriented language where everything is an object. This module covers classes, objects, inheritance, and other OOP concepts that make Ruby powerful and flexible for building complex applications.

Try It Yourself:

Ruby

# Object-Oriented Programming in Ruby

# Defining a class
class Student
  # Constructor method
  def initialize(name, age, grade)
    @name = name    # Instance variables start with @
    @age = age
    @grade = grade
  end
  
  # Getter methods
  def name
    @name
  end
  
  def age
    @age
  end
  
  def grade
    @grade
  end
  
  # Setter methods
  def name=(new_name)
    @name = new_name
  end
  
  def grade=(new_grade)
    @grade = new_grade
  end
  
  # Instance method
  def introduce
    "Hello, I'm #{@name}, a #{@age}-year-old student with grade #{@grade}."
  end
  
  # Class method
  def self.description
    "This is a Student class for managing student information."
  end
end

# Using attr_accessor for automatic getters/setters
class Course
  attr_accessor :title, :instructor, :duration
  attr_reader :students
  
  def initialize(title, instructor, duration)
    @title = title
    @instructor = instructor
    @duration = duration
    @students = []  # Initialize empty array
  end
  
  def add_student(student)
    @students << student
    puts "#{student.name} has been added to #{@title}"
  end
  
  def course_info
    <<~INFO
    Course: #{@title}
    Instructor: #{@instructor}
    Duration: #{@duration} weeks
    Students enrolled: #{@students.count}
    INFO
  end
end

# Inheritance
class ProgrammingCourse < Course
  attr_accessor :language
  
  def initialize(title, instructor, duration, language)
    super(title, instructor, duration)  # Call parent's initialize
    @language = language
  end
  
  def course_info
    super + "Language: #{@language}\n"
  end
  
  def practice
    "Practicing #{@language} programming exercises..."
  end
end

# Creating objects
student1 = Student.new("Alice", 20, "A")
student2 = Student.new("Bob", 22, "B")

puts student1.introduce
puts student2.introduce

# Using getters and setters
puts "Student1's name: #{student1.name}"
student1.grade = "A+"
puts "Updated grade: #{student1.grade}"

# Class method
puts Student.description

# Working with Course class
ruby_course = ProgrammingCourse.new("Ruby Fundamentals", "Mr. Ruby", 8, "Ruby")
ruby_course.add_student(student1)
ruby_course.add_student(student2)

puts ruby_course.course_info
puts ruby_course.practice

# Demonstrating polymorphism
courses = [
  Course.new("Web Development", "Ms. Web", 10),
  ProgrammingCourse.new("Python Basics", "Dr. Python", 6, "Python")
]

puts "\nAll courses:"
courses.each do |course|
  puts course.course_info
  puts "-" * 30
end

# Modules and mixins
module Printable
  def print_info
    puts "Printing information: #{self}"
  end
end

class Book
  include Printable
  attr_accessor :title, :author
  
  def initialize(title, author)
    @title = title
    @author = author
  end
  
  def to_s
    "#{@title} by #{@author}"
  end
end

book = Book.new("Learn Ruby", "SkillMynte")
book.print_info

Live Preview

Key Points:

Classes are defined with class ClassName (capitalized, CamelCase)
Instance variables start with @ and are available throughout the object
The initialize method is the constructor called when creating new objects
attr_accessor automatically creates getter and setter methods
attr_reader creates getters only, attr_writer creates setters only
Inheritance uses class Child < Parent syntax
super calls the parent class's method of the same name
Class methods are defined with def self.method_name
Modules are collections of methods that can be mixed into classes using include
Everything in Ruby is an object, including numbers and strings
Polymorphism allows different objects to respond to the same method call

PRACTICE PLAYGROUND

Experiment with what you've learned

Your Coding Playground: Try Your Own Ruby Code

Use this space to experiment with everything you've learned. Try writing your own Ruby programs and see the results in real-time! This is your sandbox to practice and explore Ruby programming.

Ruby

# Your Ruby Playground
# Try writing your own Ruby code here!

puts "Welcome to the Ruby Playground!"
puts "=" * 40

# Example: Simple calculator
def calculator(a, b, operation)
  case operation
  when "+"
    a + b
  when "-"
    a - b
  when "*"
    a * b
  when "/"
    b != 0 ? a / b : "Error: Division by zero"
  else
    "Invalid operation"
  end
end

# Test the calculator
puts "Calculator Examples:"
puts "5 + 3 = #{calculator(5, 3, '+')}"
puts "10 - 4 = #{calculator(10, 4, '-')}"
puts "6 * 7 = #{calculator(6, 7, '*')}"
puts "15 / 3 = #{calculator(15, 3, '/')}"

puts ""
puts "=" * 40

# Example: Student management
class Student
  attr_accessor :name, :grades
  
  def initialize(name)
    @name = name
    @grades = []
  end
  
  def add_grade(grade)
    @grades << grade
  end
  
  def average_grade
    return 0 if @grades.empty?
    @grades.sum.to_f / @grades.length
  end
  
  def display_info
    <<~INFO
    Student: #{@name}
    Grades: #{@grades.join(', ')}
    Average: #{average_grade.round(2)}
    INFO
  end
end

# Create and test student
student = Student.new("SkillMynte Learner")
student.add_grade(85)
student.add_grade(92)
student.add_grade(78)

puts student.display_info

puts ""
puts "=" * 40
puts "Now it's your turn! Modify the code above or write your own Ruby program."

# Your code here - try creating something new!
# Ideas:
# - Create a BankAccount class with deposit/withdraw methods
# - Write a method that reverses a string
# - Create a program that generates Fibonacci sequence
# - Build a simple game like rock-paper-scissors

Live Preview

Challenge Exercises:

Create a BankAccount class with:
- Account number, holder name, and balance
- Methods for deposit, withdraw, and transfer
- Balance validation to prevent overdraft
Write a program that:
- Takes a sentence as input
- Counts the number of words and characters
- Finds the longest word
- Reverses the sentence
Create a SimpleGame class:
- Rock-paper-scissors or number guessing game
- Keep score across multiple rounds
- Add computer opponent with random choices
Build a TemperatureConverter module:
- Convert between Celsius, Fahrenheit, and Kelvin
- Add validation for reasonable temperature ranges
Create a Library management system:
- Book class with title, author, ISBN
- Library class to manage book collection
- Methods to add, remove, search, and list books

Ruby Tips & Best Practices:

Use descriptive variable and method names (snake_case)
Keep methods small and focused on single responsibility
Use built-in Ruby methods instead of reinventing the wheel
Take advantage of Ruby's enumerable methods (each, map, select, etc.)
Use symbols for hash keys when possible for better performance
Follow Ruby style guide conventions
Write tests for your code (learn about RSpec or Minitest)

RUBY BASICS

Learn the fundamental concepts of Ruby programming

Module 1: Introduction to Ruby

Try It Yourself:

Key Points:

VARIABLES & DATA TYPES

Learn about Ruby's data types and variable handling

Module 2: Variables and Data Types

Try It Yourself:

Key Points:

CONTROL STRUCTURES

Learn to control program flow with conditionals and loops

Module 3: Control Structures

Try It Yourself:

Key Points:

METHODS & FUNCTIONS

Learn to create reusable code with methods

Module 4: Methods and Functions

Try It Yourself:

Key Points:

ARRAYS & HASHES

Learn to work with collections in Ruby

Module 5: Arrays and Hashes

Try It Yourself:

Key Points:

OBJECT-ORIENTED RUBY

Learn Ruby's object-oriented programming features

Module 6: Object-Oriented Programming in Ruby

Try It Yourself:

Key Points:

PRACTICE PLAYGROUND

Experiment with what you've learned

Your Coding Playground: Try Your Own Ruby Code

Challenge Exercises:

Ruby Tips & Best Practices:

Unlock Premium SkillMynte Content

Premium Courses

Certification

Mentorship

Monthly

Annual Best Value

Lifetime